package com.school.sports.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 裁判表实体类
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("referee")
public class Referee {

    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 用户ID
     */
    @NotNull(message = "用户ID不能为空")
    private Long userId;

    /**
     * 裁判等级
     */
    @Size(max = 50, message = "裁判等级长度不能超过50个字符")
    private String level;

    /**
     * 可执裁项目类型
     */
    private String qualifiedItems;

    /**
     * 执裁经历
     */
    private String experience;

    /**
     * 状态
     */
    private String status;

    /**
     * 创建时间
     */
    private LocalDateTime createdAt;

    /**
     * 用户对象（关联查询时使用）
     */
    @TableField(exist = false)
    private User user;

    /**
     * 裁判分配列表（关联查询时使用）
     */
    @TableField(exist = false)
    private List<RefereeAssignment> assignments;

    /**
     * 执裁项目数量（统计字段）
     */
    @TableField(exist = false)
    private Integer assignmentCount;

    /**
     * 裁判状态枚举
     */
    public enum RefereeStatus {
        AVAILABLE("可用"),
        BUSY("忙碌"),
        UNAVAILABLE("不可用");

        private final String displayName;

        RefereeStatus(String displayName) {
            this.displayName = displayName;
        }

        public String getDisplayName() {
            return displayName;
        }
    }

    /**
     * 裁判等级枚举
     */
    public enum RefereeLevel {
        INTERNATIONAL("国际级"),
        NATIONAL("国家级"),
        PROVINCIAL("省级"),
        CITY("市级"),
        SCHOOL("校级");

        private final String displayName;

        RefereeLevel(String displayName) {
            this.displayName = displayName;
        }

        public String getDisplayName() {
            return displayName;
        }

        /**
         * 根据显示名称获取枚举值
         */
        public static RefereeLevel fromDisplayName(String displayName) {
            for (RefereeLevel level : RefereeLevel.values()) {
                if (level.getDisplayName().equals(displayName)) {
                    return level;
                }
            }
            return null;
        }
    }

    /**
     * 获取可执裁项目类型列表
     */
    public List<String> getQualifiedItemsList() {
        if (qualifiedItems == null || qualifiedItems.trim().isEmpty()) {
            return Arrays.asList();
        }
        return Arrays.asList(qualifiedItems.split("、"));
    }

    /**
     * 设置可执裁项目类型列表
     */
    public void setQualifiedItemsList(List<String> items) {
        if (items == null || items.isEmpty()) {
            this.qualifiedItems = null;
        } else {
            this.qualifiedItems = String.join("、", items);
        }
    }

    /**
     * 检查是否可以执裁指定项目
     */
    public boolean canJudgeProject(String projectType) {
        if (qualifiedItems == null || qualifiedItems.trim().isEmpty()) {
            return false;
        }
        return Arrays.asList(qualifiedItems.split("、")).contains(projectType);
    }

    /**
     * 获取裁判等级级别数值（用于排序）
     */
    public Integer getLevelRank() {
        if (level == null) return 0;

        RefereeLevel refereeLevel = RefereeLevel.fromDisplayName(level);
        if (refereeLevel == null) return 0;

        switch (refereeLevel) {
            case INTERNATIONAL: return 5;
            case NATIONAL: return 4;
            case PROVINCIAL: return 3;
            case CITY: return 2;
            case SCHOOL: return 1;
            default: return 0;
        }
    }

    /**
     * 检查裁判是否为高级别裁判
     */
    public boolean isSeniorReferee() {
        Integer rank = getLevelRank();
        return rank != null && rank >= 3;
    }

    /**
     * 检查执裁经历是否丰富
     */
    public boolean hasRichExperience() {
        return experience != null && experience.length() > 20;
    }

    /**
     * 获取裁判状态（根据分配情况判断）
     */
    public String getRefereeStatus() {
        if (assignments == null || assignments.isEmpty()) {
            return RefereeStatus.AVAILABLE.getDisplayName();
        }

        long activeAssignments = assignments.stream()
                .filter(assignment -> "已接受".equals(assignment.getStatus()))
                .count();

        if (activeAssignments > 0) {
            return RefereeStatus.BUSY.getDisplayName();
        }

        return RefereeStatus.AVAILABLE.getDisplayName();
    }

    /**
     * 获取裁判显示名称
     */
    public String getDisplayName() {
        if (user != null) {
            return user.getRealName() + "(" + level + ")";
        }
        return level != null ? level : "未知裁判";
    }

    /**
     * 获取联系方式
     */
    public String getContactInfo() {
        if (user != null) {
            return "电话：" + user.getPhone() + " | 邮箱：" + user.getEmail();
        }
        return "联系方式未知";
    }

    /**
     * 检查裁判信息是否完整
     */
    public boolean isProfileComplete() {
        return level != null && !level.trim().isEmpty()
                && qualifiedItems != null && !qualifiedItems.trim().isEmpty()
                && experience != null && !experience.trim().isEmpty();
    }

    /**
     * 获取执裁统计信息
     */
    public String getAssignmentStatistics() {
        if (assignments == null) {
            return "暂无执裁任务";
        }

        long accepted = assignments.stream()
                .filter(assignment -> "已接受".equals(assignment.getStatus()))
                .count();

        long pending = assignments.stream()
                .filter(assignment -> "待确认".equals(assignment.getStatus()))
                .count();

        return String.format("已接受：%d，待确认：%d", accepted, pending);
    }

    /**
     * 从关联对象同步字段信息
     */
    public void syncFieldsFromObjects() {
        if (user != null && level == null) {
            // 如果没有设置裁判等级，可以根据用户信息或其他逻辑设置
            // 这里只是示例，实际业务中可能需要更复杂的逻辑
        }
    }

    /**
     * 比较裁判等级（用于排序）
     */
    public int compareLevel(Referee other) {
        if (other == null) return 1;
        return Integer.compare(this.getLevelRank(), other.getLevelRank());
    }

    /**
     * 获取裁判专业领域
     */
    public List<String> getExpertiseAreas() {
        return getQualifiedItemsList().stream()
                .filter(area -> area != null && !area.trim().isEmpty())
                .collect(Collectors.toList());
    }

    /**
     * 检查是否可以接受新的分配
     */
    public boolean canAcceptAssignment() {
        String status = getRefereeStatus();
        return RefereeStatus.AVAILABLE.getDisplayName().equals(status);
    }
}